// 用户认证相关工具方法
import API from '@/api/index.js';
import { generateUUID } from './common.js';
import { SocialTypeEnum } from './constants.js';
import store from '@/store/index.js';

// 全局登录状态控制
let globalLoginInProgress = false;
let loginPromise = null;

/**
 * 获取token
 * @returns {String} token值
 */
export function getToken() {
  return uni.getStorageSync('token');
}

/**
 * 存储token
 * @param {Object} tokenInfo - 包含token, refreshToken等信息
 */
export function setToken(tokenInfo) {
  if (!tokenInfo) return;
  
  const { accessToken, refreshToken, expiresTime, openid } = tokenInfo;
  
  // 存储登录信息
  uni.setStorageSync('token', accessToken);
  uni.setStorageSync('refreshToken', refreshToken);
  uni.setStorageSync('expiresTime', expiresTime);
  uni.setStorageSync('isLogin', true);
  uni.setStorageSync('openid', openid);
}

/**
 * 清除token
 */
export function removeToken() {
  uni.removeStorageSync('token');
  uni.removeStorageSync('refreshToken');
  uni.removeStorageSync('expiresTime');
  uni.removeStorageSync('userInfo');
  uni.removeStorageSync('userId');
  uni.setStorageSync('isLogin', false);
}

/**
 * 判断token是否过期
 * @returns {Boolean} 是否过期
 */
export function isTokenExpired() {
  const expiresTime = uni.getStorageSync('expiresTime');
  if (!expiresTime) return true;
  
  // token有效期前5分钟就认为即将过期
  const currentTime = new Date().getTime();
  return currentTime >= (expiresTime - 5 * 60 * 1000);
}

/**
 * 刷新token
 * @returns {Promise} 刷新结果
 */
export async function refreshTokenFn() {
  try {
    const refreshToken = uni.getStorageSync('refreshToken');
    if (!refreshToken) {
      removeToken();
      return Promise.reject('无refreshToken');
    }
    
    const result = await API.user.refreshToken(refreshToken);
    // 设置本地存储中的token
    setToken(result);
    
    // 更新Vuex中的token状态
    const store = require('@/store').default;
    store.commit('user/SET_TOKEN_INFO', {
      accessToken: result.accessToken,
      refreshToken: result.refreshToken,
      expiresTime: result.expiresTime
    });
    store.commit('user/SET_LOGIN_STATUS', true);
    
    return Promise.resolve(result);
  } catch (error) {
    removeToken();
    return Promise.reject(error);
  }
}

/**
 * 微信小程序登录（无需手机号，使用社交登录接口）
 * @returns {Promise} 登录结果
 */
export function wxMiniLogin() {
  return new Promise((resolve, reject) => {
    const state = generateUUID();
    
    // 获取小程序启动时的场景值
    let scene = 0; // 默认场景值改为0
    // #ifdef MP-WEIXIN
    try {
      const launchOptions = wx.getLaunchOptionsSync();
      if (launchOptions && launchOptions.scene) {
        scene = launchOptions.scene;
        console.log('获取到微信小程序场景值:', scene);
      }
    } catch (e) {
      console.error('获取场景值失败:', e);
    }
    // #endif
    
    uni.login({
      provider: 'weixin',
      success: loginRes => {
        const code = loginRes.code;
        
        // 调用社交登录接口，使用枚举定义的微信小程序类型
        API.user.socialLogin({
          type: SocialTypeEnum.WECHAT_MINI_APP.type, // 微信小程序类型
          code: code,
          state: state,
          scene: scene // 添加场景值参数
        }).then(result => {
          // 保存登录状态
          setToken(result);
          resolve(result);
        }).catch(error => {
          reject(error);
        });
      },
      fail: err => {
        console.error('微信登录失败:', err);
        reject(err);
      }
    });
  });
}

/**
 * 全局统一的自动登录方法，确保全局只有一个登录流程
 * @returns {Promise<boolean>} 是否登录成功
 */
export async function globalAutoLogin() {
  // 如果已经有登录进行中，返回已存在的登录Promise
  if (globalLoginInProgress) {
    return loginPromise;
  }

  // 设置全局登录状态
  globalLoginInProgress = true;
  
  // 创建登录Promise
  loginPromise = new Promise(async (resolve) => {
    try {
      // 获取Store
      const store = require('@/store').default;
      
      // 检查登录状态
      const isLoggedIn = await checkLoginStatus();
      if (isLoggedIn) {
        resolve(true);
        return;
      }
      
      // 获取当前平台类型
      const platformType = store.state.app.appInfo.platformType;
      
      // 微信小程序环境下使用微信登录
      if (platformType === 'mp') {
        // #ifdef MP-WEIXIN
        // 使用wxMiniLogin进行登录
        await wxMiniLogin();
        // 获取用户信息
        await store.dispatch('user/getUserInfo');
        
        // 检查用户资料完整度
        const userInfo = store.state.user.userInfo;
        const profileStatus = checkProfileCompleteness(userInfo);
        
        // 记录资料完整状态，供页面判断是否需要引导
        uni.setStorageSync('profile_status', profileStatus);
        
        resolve(true);
        // #endif
      } 
      // H5或APP环境下，显示登录弹窗
      else if (['h5', 'app'].includes(platformType)) {
        // #ifndef MP-WEIXIN
        // 显示登录弹窗
        try {
          await store.dispatch('app/showLoginDialog');
          // 登录成功
          resolve(true);
        } catch (error) {
          console.error('登录弹窗操作失败:', error);
          resolve(false);
        }
        // #endif
      } else {
        // 其他未识别的平台
        resolve(false);
      }
    } catch (error) {
      console.error('全局自动登录失败:', error);
      resolve(false);
    } finally {
      // 登录完成，无论成功失败都重置状态
      globalLoginInProgress = false;
      setTimeout(() => {
        // 一段时间后清除登录Promise，允许下次重新登录
        loginPromise = null;
      }, 1000);
    }
  });
  
  return loginPromise;
}

/**
 * 检查用户资料完整度
 * @param {Object} userInfo 用户信息
 * @returns {Object} 资料完整度状态
 */
export function checkProfileCompleteness(userInfo) {
  if (!userInfo) {
    return {
      isComplete: false,
      completionPercentage: 0,
      missingFields: ['全部资料']
    };
  }
  
  // 检查昵称是否为系统生成的默认格式
  const isDefaultNickname = userInfo.nickname && userInfo.nickname.startsWith('用户') && /^用户\d+$/.test(userInfo.nickname);
  
  // 定义资料字段及其重要性
  const profileFields = {
    // 核心资料（必填）- 每项20%，共80%
    nickname: { value: !!userInfo.nickname && !isDefaultNickname, weight: 20 },
    avatar: { value: !!userInfo.avatar, weight: 20 },
    sex: { value: userInfo.sex > 0, weight: 20 },
    age: { value: !!userInfo.age, weight: 20 },
    
    // 次要资料 - 权重较低，共20%
    signature: { value: !!userInfo.signature, weight: 20 }
    
    // 保留扩展空间，后续可以增加更多字段：
    // region: { value: !!userInfo.region, weight: 10 },
    // gameTypes: { value: Array.isArray(userInfo.gameTypes) && userInfo.gameTypes.length > 0, weight: 5 },
    // ...更多字段
  };
  
  // 计算总权重和完成字段的权重
  const totalWeight = Object.values(profileFields).reduce((sum, field) => sum + field.weight, 0);
  const completedWeight = Object.values(profileFields).reduce((sum, field) => sum + (field.value ? field.weight : 0), 0);
  
  // 计算完成百分比
  const completionPercentage = Math.round((completedWeight / totalWeight) * 100);
  
  // 获取缺失的字段
  const missingFields = [];
  for (const [field, data] of Object.entries(profileFields)) {
    if (!data.value) {
      missingFields.push(field);
    }
  }
  
  // 核心资料是否都已完成
  const isCoreComplete = profileFields.nickname.value && 
                        profileFields.avatar.value && 
                        profileFields.sex.value && 
                        profileFields.age.value;
  
  return {
    isComplete: completionPercentage >= 70, // 70%以上视为"基本完整"
    isCoreComplete,
    completionPercentage,
    missingFields
  };
}

/**
 * 检查登录状态
 * @returns {Promise<boolean>}
 */
export async function checkLoginStatus() {
  try {
    // 从Vuex获取登录状态
    const store = require('@/store').default;
    const isLogin = store.state.user.isLogin;
    const token = store.state.user.token;
    
    if (isLogin && token) {
      return true;
    }
    
    // 尝试从本地存储获取token并更新到Vuex
    const localToken = uni.getStorageSync('token');
    
    if (localToken) {
      // 更新token到Vuex
      store.commit('user/SET_TOKEN_INFO', {
        accessToken: localToken,
        refreshToken: uni.getStorageSync('refreshToken'),
        expiresTime: uni.getStorageSync('tokenExpire')
      });
      
      // 添加：设置登录状态为true
      store.commit('user/SET_LOGIN_STATUS', true);
      
      // 尝试获取用户信息
      try {
        await store.dispatch('user/getUserInfo');
        
        // 用户信息获取成功，清除profile_guide_skipped记录
        // 确保登录后可以重新检查资料完整度
        uni.removeStorageSync('profile_guide_skipped');
        
        return true;
      } catch (error) {
        console.error('获取用户信息失败:', error);
        // 获取用户信息失败，清除token和登录状态
        store.commit('user/CLEAR_USER_INFO');
        return false;
      }
    }
    
    return false;
  } catch (error) {
    console.error('检查登录状态异常:', error);
    return false;
  }
} 